/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
#include <stdio.h>
#include <iostream>

// 友元类
// 让某个类B成为类A的友元类，这样的话，类B就可以在其成员函数中访问类A的所有成员（包括成员函数，成员变量）
// 而不管这些成员在类A中是用什么访问修饰符来进行修饰的（public, private, protected）
// 如果现在类A和类B都变成了类模板，那能否让类模板B成为类模板A的友元类模板呢？

// 让类模板中的某个实例成为友元类

// 让类模板成为友元类模板

// 让类型模板参数成为友元类
// C++11新标准中引入的，如果传递进来的类型模板参数是一个类类型，
// 则这个类类型可以成为当前类模板的友元类

namespace _nmsp1
{
    template<typename U> class B;   // 类模板B的声明
    // 如果需要将类模板B作为A的友元类，那么还需要在A类模板前加上类模板B的声明
    // 注意这里，如果B不是一个类模板，只是一个普通类的话，就不需要在类模板前面加B的类声明
    // 加模板声明只是类模板添加友元类模板的语法规则
    template<typename T>
    class A
    {
        // 注意这里，不需要加任何private,public,protected修饰符，因为在friend的情况下，这些修饰符没有任何意义
        friend class B<float>;
        // 这里就实现了，让类模板B的特定实例类型B<float>成为了类模板A的友元类
    private:
        int data;
    };
    
    template<typename T>
    class B
    {
    public:
        void callBAfunc()
        {
            // 如果B是A的友元，那么这个函数就能访问A的私有成员变量
            A<int> aobj;  
            aobj.data = 100;
            std::cout << aobj.data << std::endl;
        }
    };
    
    void func()
    {
        B<float> bObj;
        bObj.callBAfunc();
        // 100
    }
}

namespace _nmsp2
{
    // template<typename U> class B;   // 类模板B的声明
    // 如果是将类模板B做为类模板A的友元类模板，
    // 那么这里就不再需要在A类模板前进行B的类模板声明了（当然，你加上也不会编译报错）
    template<typename T>
    class A
    {
        // 注意这里，不需要加任何private,public,protected修饰符，因为在friend的情况下，这些修饰符没有任何意义
        template<typename> friend class B;
        // 这里就实现了，让类模板B成为了类模板A的友元类模板
    private:
        int data;
    };
    
    template<typename T>
    class B
    {
    public:
        void callBAfunc()
        {
            // 如果B是A的友元，那么这个函数就能访问A的私有成员变量
            A<int> aobj;  
            aobj.data = 100;
            std::cout << aobj.data << std::endl;
        }
    };
    
    void func()
    {
        B<float> bObj;
        bObj.callBAfunc();
        // 100
        
        B<std::string> sbobj;
        sbobj.callBAfunc();
        // 100
    }
}

namespace _nmsp3
{
    template<typename T>
    class A
    {
        friend T;
        // 如果传递给类模板A的模板参数不是一个类类型,那么这行友元类类型代码就会被忽略
        friend class CF;
        // 这行代码就表示，不管你CF类模板被实例化成那种类型，CF实例化的类都是我A的友元类
        
    private:
        int data;
    };
    
    
    class CF
    {
    public:
        void callAfunc()
        {
            // 注意这里：实例化A类型的时候，传递进去的类型模板参数是CF这个类（类类型本身）
            A<CF> aobj1;
            // 这个代码行的效果是，让传递进来的CF这个类，成为了A<CF>这个类的友元类
            // 然后既然CF成为了类A<CF>的友元，
            // 那么CF类的成员函数中，就能够访问类A<CF>对象aobj1的私有成员
            aobj1.data = 1234;
            std::cout <<  aobj1.data<< std::endl;
            
            // 注意这里，在类CF的成员函数中，这句话要好好理解
            // 因为如果你不在CF类的成员函数中，而是在外面访问A<CF>类对象的私有成员，是访问不到的
        
            
            
            // 如果传递给类模板A的模板参数不是一个类类型,那么这行友元类类型代码就会被忽略
            // 比如这里,我们不传递类类型参数,传递一个int
            A<int> abok2;
            abok2.data = 1342;
            std::cout << abok2.data << std::endl;
            // 编译报错，不能再类外访问类的私有成员
            // 因为对于这行代码来讲的话，abok2是一个A<int>类型，把int传递进去的话，就变成了friend int;
            // int 类型是是友元，那么abok2和CF这个类没有任何关系，CF类并不是A<int>的类对象abok2的友元类
            // 自然也就不能再CF的成员函数中访问A<int>的类对象abok2的私有成员了
            
            
            // 当然，如果你在类A中把CF这个类模板添加为友元类，那么这些限制就都不纯在了
            // 不管你CF被实例化为何种类型，都是A的友元类，那么就都可以在这里（CF的成员函数中访问类A的私有成员）
        }
    };
    
    
    void func()
    {
        CF mycf;
        mycf.callAfunc();
        // 1234
        
        // A<CF> acfObj;
        // acfObj.data = 100;
        // 注意这里，在类CF的成员函数中，这句话要好好理解
        // 因为如果你不在CF类的成员函数中，而是在外面访问A<CF>类对象的私有成员，是访问不到的
        // 因为只能在CF类的成员函数中访问A<CF>类对象的私有成员，所以在外面你声明了一个A<CF>类对象，
        // 也是不能访问到A<CF>类对象的私有成员的
        
    }
}

int main()
{
    // _nmsp1::func();
    // _nmsp2::func();
    _nmsp3::func();

    return 0;
}
